Below is an updated R Markdown file that groups all Likert-type (ordered factor) columns together into combined stacked bar plots. It groups Likert columns that share the same set/ordering of levels (e.g., Agree scale vs Helpfulness scale) and produces one horizontal proportional stacked bar chart per group showing each question as a stacked bar (percentages by response). Non-Likert columns are still shown individually (numeric => histogram+boxplot, unordered factor => bar).
Save as survey_plots_likert_grouped.Rmd (in the same folder as course_survey_responses.csv) and knit or render.
This document reads course_survey_responses.csv, coerces Likert-like columns to ordered factors, and:
Place course_survey_responses.csv in the same directory as this .Rmd (or change the data_file path below).
if (!requireNamespace("pacman", quietly = TRUE)) install.packages("pacman")
pacman::p_load(tidyverse, janitor, forcats, scales, ggthemes)
# patchwork is optional for numeric combined plots
if (!requireNamespace("patchwork", quietly = TRUE)) {
message("To get combined histogram+boxplot layout install.packages('patchwork')")
}data_file <- "../data/survey/course_survey_responses.csv"
df_raw <- readr::read_csv(data_file, locale = readr::locale(encoding = "UTF-8"), na = c("", "NA"))
# Keep a cleaned-names version for programming but preserve original names for labels
df <- df_raw %>% janitor::clean_names()
# Show a small preview
dplyr::glimpse(df)Rows: 43
Columns: 56
$ consent <chr> …
$ prior_coding_experience <chr> …
$ frequency_of_ai_use_in_this_course <chr> …
$ helpfulness_of_generative_ai_for_each_use_case_suggesting_r_code_to_solve_problems <chr> …
$ helpfulness_of_generative_ai_for_each_use_case_explaining_r_code_syntax_and_logic <chr> …
$ helpfulness_of_generative_ai_for_each_use_case_improving_code_comments_and_readability <chr> …
$ helpfulness_of_generative_ai_for_each_use_case_brainstorming_research_questions_with_neon_metagenomic_data <chr> …
$ helpfulness_of_generative_ai_for_each_use_case_vibe_code_generating_statistical_network_or_other_advanced_analyses <chr> …
$ helpfulness_of_generative_ai_for_each_use_case_data_wrangling_with_mag_taxonomy_genome_properties_soil_chemistry <chr> …
$ helpfulness_of_generative_ai_for_each_use_case_understanding_outputs_plots_statistics_model_diagnostics <chr> …
$ helpfulness_of_generative_ai_for_each_use_case_using_r_studio_via_open_on_demand_on_the_hpc <chr> …
$ could_you_give_short_examples_of_a_helpful_ai_response <chr> …
$ could_you_give_short_examples_of_unhelpful_or_incorrect_ai_responses <chr> …
$ impact_on_learning_ai_made_learning_r_easier <chr> …
$ impact_on_learning_ai_helped_me_understand_r_syntax_and_functions <chr> …
$ impact_on_learning_ai_increased_my_confidence_in_writing_r_code <chr> …
$ impact_on_learning_ai_helped_me_learn_from_errors_more_efficiently <chr> …
$ impact_on_learning_ai_encouraged_me_to_try_more_complex_tasks_than_i_would_have_otherwise <chr> …
$ impact_on_metagenomics_learning_ai_improved_my_understanding_of_mag_taxonomy <chr> …
$ impact_on_metagenomics_learning_ai_helped_connect_genome_properties_with_soil_chemistry <chr> …
$ impact_on_metagenomics_learning_ai_improved_my_ability_to_form_testable_questions_using_neon_data <chr> …
$ impact_on_metagenomics_learning_ai_helped_me_interpret_r_outputs_for_metagenomics <chr> …
$ impact_on_metagenomics_learning_ai_improved_my_overall_conceptual_grasp_of_metagenomics <chr> …
$ confidence_change_in_programming_in_r <chr> …
$ how_much_time_did_using_ai_save_me <chr> …
$ code_quality_outcomes_using_ai_my_code_became_more_correct_fewer_errors <chr> …
$ code_quality_outcomes_using_ai_my_code_became_more_readable_better_comments_structure <chr> …
$ code_quality_outcomes_using_ai_my_code_became_more_efficient_faster_simpler <chr> …
$ code_quality_outcomes_using_ai_my_analyses_became_more_reproducible_clear_steps_scripts <chr> …
$ code_quality_outcomes_using_ai_i_relied_on_ai_but_still_validated_results <chr> …
$ frequency_of_incorrect_ai_output <chr> …
$ when_ai_was_wrong_i_typically <chr> …
$ common_issues_encountered <chr> …
$ trust_calibration_i_can_usually_tell_when_ai_is_wrong <chr> …
$ trust_calibration_i_know_how_to_verify_ai_generated_code <chr> …
$ trust_calibration_ai_responses_are_transparent_about_uncertainty_limitations <chr> …
$ trust_calibration_ai_sometimes_overstates_confidence_in_its_answers <chr> …
$ ethical_alignment_using_ai_in_this_course_felt_appropriate_and_ethical <chr> …
$ ethical_alignment_clear_guidelines_were_provided_for_ai_use <chr> …
$ ethical_alignment_ai_use_encouraged_learning_not_shortcuts <chr> …
$ ethical_alignment_i_understand_when_how_to_credit_ai_assistance <chr> …
$ did_you_become_more_engaged_or_interactive_in_solving_problems_using_ai <chr> …
$ inquiry_exploration_ai_helped_me_identify_novel_questions_using_neon_geographic_variation <chr> …
$ inquiry_exploration_ai_helped_me_connect_ma_gs_to_environmental_gradients <chr> …
$ inquiry_exploration_ai_exposed_me_to_new_analytical_methods <chr> …
$ inquiry_exploration_ai_helped_me_scope_feasible_workflows_for_our_data <chr> …
$ vibe_code_outcomes_ai_generated_advanced_code_was_runnable_in_our_environment <chr> …
$ vibe_code_outcomes_i_understood_at_least_the_core_idea_of_the_advanced_methods <chr> …
$ vibe_code_outcomes_i_could_critically_evaluate_the_appropriateness_of_those_methods <chr> …
$ vibe_code_outcomes_i_would_be_able_to_reproduce_the_analysis_later_with_notes <chr> …
$ clarity_of_instructions_on_ai_use <chr> …
$ where_more_support_would_help <chr> …
$ suggested_changes_for_future_offerings <chr> …
$ overall_effectiveness_of_ai_in_this_course <dbl> …
$ likelihood_to_recommend_ai_use_in_similar_courses <dbl> …
$ final_comments_and_suggestions <chr> …Modify the level vectors below if your survey uses different exact wording.
# Likert / scale levels (edit to match your exact text if needed)
helpful_levels <- c("Not at all helpful","Slightly helpful","Moderately helpful","Very helpful","Extremely helpful")
agree_levels <- c("Strongly disagree","Disagree","Neutral","Agree","Strongly agree")
yesno_levels <- c("No","Yes")
engagement_levels <- c("Much less engaged","Slightly less engaged","No change","Slightly more engaged","Much more engaged")
# Robust coercion helper for character/factor columns:
coerce_likert <- function(vec) {
u_raw <- as.character(vec)
u <- stringr::str_trim(u_raw) # trim whitespace
# normalize some common variants to canonical forms
u_norm <- dplyr::case_when(
u %in% c("Strong disagree") ~ "Strongly disagree",
u %in% c("Strong agree") ~ "Strongly agree",
TRUE ~ u
)
# If all values are NA or in helpful_levels -> ordered helpful factor
if (all(is.na(u_norm) | u_norm %in% helpful_levels)) {
return(factor(u_norm, levels = helpful_levels, ordered = TRUE))
}
# If all values are NA or in agree_levels (including normalized variants) -> ordered agree factor
if (all(is.na(u_norm) | u_norm %in% agree_levels)) {
return(factor(u_norm, levels = agree_levels, ordered = TRUE))
}
# If all values are NA or in yes/no -> ordered yes/no
if (all(is.na(u_norm) | u_norm %in% yesno_levels)) {
return(factor(u_norm, levels = yesno_levels, ordered = TRUE))
}
# If all values are NA or in engagement_levels -> ordered engagement
if (all(is.na(u_norm) | u_norm %in% engagement_levels)) {
return(factor(u_norm, levels = engagement_levels, ordered = TRUE))
}
# If non-missing entries look like integers (e.g., "1","10"), convert to numeric
u_non_na <- u_norm[!is.na(u_norm)]
if (length(u_non_na) > 0 && all(stringr::str_detect(u_non_na, "^\\d+$"))) {
return(as.numeric(u_norm))
}
# Fallback: return as (unordered) factor including NA as a level if present
return(forcats::as_factor(u_norm))
}df_plot <- df %>%
mutate(across(everything(), ~ {
v <- .
if (is.numeric(v)) return(v)
if (is.character(v) || is.factor(v)) return(coerce_likert(v))
return(v)
}))
# Use the original (raw) names for nicer labels:
orig_names <- names(df_raw)
clean_names <- names(df)
name_map <- tibble(clean = clean_names, orig = orig_names)
# Summary of inferred types (note: n_distinct uses na.rm; fix from earlier bug)
vars_summary <- tibble(
column = names(df_plot),
r_type = map_chr(df_plot, ~ class(.x)[1]),
unique_values = map_int(df_plot, ~ n_distinct(.x, na.rm = TRUE))
)
knitr::kable(vars_summary, caption = "Inferred types and distinct counts")| column | r_type | unique_values |
|---|---|---|
| consent | factor | 1 |
| prior_coding_experience | factor | 5 |
| frequency_of_ai_use_in_this_course | factor | 4 |
| helpfulness_of_generative_ai_for_each_use_case_suggesting_r_code_to_solve_problems | factor | 5 |
| helpfulness_of_generative_ai_for_each_use_case_explaining_r_code_syntax_and_logic | factor | 5 |
| helpfulness_of_generative_ai_for_each_use_case_improving_code_comments_and_readability | factor | 5 |
| helpfulness_of_generative_ai_for_each_use_case_brainstorming_research_questions_with_neon_metagenomic_data | factor | 5 |
| helpfulness_of_generative_ai_for_each_use_case_vibe_code_generating_statistical_network_or_other_advanced_analyses | ordered | 4 |
| helpfulness_of_generative_ai_for_each_use_case_data_wrangling_with_mag_taxonomy_genome_properties_soil_chemistry | factor | 5 |
| helpfulness_of_generative_ai_for_each_use_case_understanding_outputs_plots_statistics_model_diagnostics | factor | 5 |
| helpfulness_of_generative_ai_for_each_use_case_using_r_studio_via_open_on_demand_on_the_hpc | factor | 5 |
| could_you_give_short_examples_of_a_helpful_ai_response | factor | 41 |
| could_you_give_short_examples_of_unhelpful_or_incorrect_ai_responses | factor | 41 |
| impact_on_learning_ai_made_learning_r_easier | ordered | 4 |
| impact_on_learning_ai_helped_me_understand_r_syntax_and_functions | factor | 5 |
| impact_on_learning_ai_increased_my_confidence_in_writing_r_code | ordered | 4 |
| impact_on_learning_ai_helped_me_learn_from_errors_more_efficiently | ordered | 4 |
| impact_on_learning_ai_encouraged_me_to_try_more_complex_tasks_than_i_would_have_otherwise | factor | 5 |
| impact_on_metagenomics_learning_ai_improved_my_understanding_of_mag_taxonomy | ordered | 5 |
| impact_on_metagenomics_learning_ai_helped_connect_genome_properties_with_soil_chemistry | ordered | 5 |
| impact_on_metagenomics_learning_ai_improved_my_ability_to_form_testable_questions_using_neon_data | ordered | 4 |
| impact_on_metagenomics_learning_ai_helped_me_interpret_r_outputs_for_metagenomics | ordered | 5 |
| impact_on_metagenomics_learning_ai_improved_my_overall_conceptual_grasp_of_metagenomics | ordered | 5 |
| confidence_change_in_programming_in_r | factor | 4 |
| how_much_time_did_using_ai_save_me | factor | 5 |
| code_quality_outcomes_using_ai_my_code_became_more_correct_fewer_errors | ordered | 3 |
| code_quality_outcomes_using_ai_my_code_became_more_readable_better_comments_structure | ordered | 4 |
| code_quality_outcomes_using_ai_my_code_became_more_efficient_faster_simpler | ordered | 4 |
| code_quality_outcomes_using_ai_my_analyses_became_more_reproducible_clear_steps_scripts | ordered | 4 |
| code_quality_outcomes_using_ai_i_relied_on_ai_but_still_validated_results | ordered | 4 |
| frequency_of_incorrect_ai_output | factor | 4 |
| when_ai_was_wrong_i_typically | factor | 20 |
| common_issues_encountered | factor | 21 |
| trust_calibration_i_can_usually_tell_when_ai_is_wrong | ordered | 4 |
| trust_calibration_i_know_how_to_verify_ai_generated_code | ordered | 5 |
| trust_calibration_ai_responses_are_transparent_about_uncertainty_limitations | ordered | 4 |
| trust_calibration_ai_sometimes_overstates_confidence_in_its_answers | ordered | 4 |
| ethical_alignment_using_ai_in_this_course_felt_appropriate_and_ethical | ordered | 5 |
| ethical_alignment_clear_guidelines_were_provided_for_ai_use | ordered | 5 |
| ethical_alignment_ai_use_encouraged_learning_not_shortcuts | ordered | 4 |
| ethical_alignment_i_understand_when_how_to_credit_ai_assistance | ordered | 5 |
| did_you_become_more_engaged_or_interactive_in_solving_problems_using_ai | ordered | 5 |
| inquiry_exploration_ai_helped_me_identify_novel_questions_using_neon_geographic_variation | ordered | 4 |
| inquiry_exploration_ai_helped_me_connect_ma_gs_to_environmental_gradients | ordered | 5 |
| inquiry_exploration_ai_exposed_me_to_new_analytical_methods | ordered | 4 |
| inquiry_exploration_ai_helped_me_scope_feasible_workflows_for_our_data | ordered | 4 |
| vibe_code_outcomes_ai_generated_advanced_code_was_runnable_in_our_environment | ordered | 4 |
| vibe_code_outcomes_i_understood_at_least_the_core_idea_of_the_advanced_methods | ordered | 5 |
| vibe_code_outcomes_i_could_critically_evaluate_the_appropriateness_of_those_methods | ordered | 4 |
| vibe_code_outcomes_i_would_be_able_to_reproduce_the_analysis_later_with_notes | ordered | 5 |
| clarity_of_instructions_on_ai_use | factor | 4 |
| where_more_support_would_help | factor | 30 |
| suggested_changes_for_future_offerings | factor | 30 |
| overall_effectiveness_of_ai_in_this_course | numeric | 5 |
| likelihood_to_recommend_ai_use_in_similar_courses | numeric | 8 |
| final_comments_and_suggestions | factor | 31 |
plot_numeric <- function(df, col) {
col_sym <- rlang::sym(col)
p_hist <- ggplot(df, aes(x = !!col_sym)) +
geom_histogram(fill = "#2b8cbe", color = "white", bins = 30, alpha = 0.9) +
labs(title = col, x = col, y = "Count") +
theme_minimal()
p_box <- ggplot(df, aes(y = !!col_sym)) +
geom_boxplot(fill = "#2b8cbe", alpha = 0.7) +
labs(x = "", y = col) +
theme_minimal()
if (requireNamespace("patchwork", quietly = TRUE)) {
return(p_hist / p_box + patchwork::plot_layout(heights = c(3, 1)))
} else {
return(p_hist)
}
}
plot_unordered_factor <- function(df, col, top_n = 20) {
col_sym <- rlang::sym(col)
tb <- df %>% mutate(tmp = !!col_sym) %>% count(tmp, sort = TRUE, name = "n")
n_unique <- nrow(tb)
if (n_unique > top_n) {
top_vals <- tb %>% slice_max(n, n = top_n) %>% pull(tmp)
tb2 <- tb %>% mutate(tmp2 = ifelse(tmp %in% top_vals, as.character(tmp), "Other")) %>%
group_by(tmp2) %>% summarise(n = sum(n), .groups = "drop") %>%
arrange(n) %>% mutate(tmp2 = forcats::fct_reorder(tmp2, n))
p <- ggplot(tb2, aes(x = tmp2, y = n, fill = tmp2)) +
geom_col(show.legend = FALSE) + labs(title = col, x = NULL, y = "Count") +
theme_minimal() + theme(axis.text.x = element_text(angle = 0, hjust = 0.5))
return(p)
} else {
tb2 <- tb %>% arrange(n) %>% mutate(tmp = forcats::fct_reorder(as.character(tmp), n))
p <- ggplot(tb2, aes(x = tmp, y = n, fill = tmp)) + geom_col(show.legend = FALSE) +
labs(title = col, x = NULL, y = "Count") + theme_minimal() +
theme(axis.text.x = element_text(angle = 0, hjust = 0.5))
return(p)
}
}This code finds all ordered-factor columns, groups those that share the same level set (and ordering), and produces one horizontal proportional stacked bar chart per group. Each question appears as its own stacked bar with colors for responses. Question labels use the original column names when available.
# find ordered (Likert-like) columns
likert_cols <- names(df_plot)[purrr::map_lgl(df_plot, is.ordered)]
if (length(likert_cols) == 0) {
cat("No ordered (Likert-like) columns detected.\n")
} else {
# group by levels signature so columns with same level sets are combined
signature <- function(f) paste(levels(df_plot[[f]]), collapse = "||")
groups <- likert_cols %>% split(., map_chr(., signature))
i <- 1
for (sig in names(groups)) {
cols <- groups[[sig]]
# prepare long table
long <- df_plot %>%
select(all_of(cols)) %>%
pivot_longer(cols = everything(), names_to = "clean_name", values_to = "response") %>%
mutate(response = factor(response, levels = levels(df_plot[[cols[1]]]), ordered = is.ordered(df_plot[[cols[1]]]))) %>%
group_by(clean_name, response) %>%
summarise(n = sum(!is.na(response)), .groups = "drop") %>%
group_by(clean_name) %>%
mutate(pct = n / sum(n)) %>%
ungroup() %>%
left_join(name_map, by = c("clean_name" = "clean")) %>%
mutate(orig_label = ifelse(is.na(orig), clean_name, orig))
# reorder questions by mean/median score so bars have a meaningful order (higher positivity on top)
# compute a numeric score per response level:
levs <- levels(df_plot[[cols[1]]])
score_map <- tibble(response = levs, score = seq_along(levs))
ordering <- long %>%
left_join(score_map, by = "response") %>%
group_by(clean_name, orig_label) %>%
summarise(mean_score = sum(score * pct), .groups = "drop") %>%
arrange(mean_score) # lowest to highest
long <- long %>%
mutate(orig_label = factor(orig_label, levels = ordering$orig_label))
# plot: horizontal proportional stacked bar
p <- ggplot(long, aes(x = orig_label, y = pct, fill = response)) +
geom_col(position = "fill", color = "white") +
coord_flip() +
scale_y_continuous(labels = scales::percent_format()) +
labs(title = paste0("Likert group ", i, " — questions sharing levels:"),
subtitle = paste(levs, collapse = " | "),
x = NULL, y = "Percent", fill = "") +
theme_minimal() +
theme(legend.position = "bottom", axis.text.y = element_text(size = 10))
cat("\n\n## Likert group ", i, "\n\n", sep = "")
print(p)
# show a small counts table (top rows)
counts_tbl <- long %>% select(orig_label, response, n) %>% arrange(orig_label, desc(n))
print(knitr::kable(head(counts_tbl, 100), caption = paste0("Counts for Likert group ", i, " (by question and response)")))
i <- i + 1
}
}
| orig_label | response | n |
|---|---|---|
| Did you become more engaged or interactive in solving problems using AI? | Slightly more engaged | 23 |
| Did you become more engaged or interactive in solving problems using AI? | Slightly less engaged | 9 |
| Did you become more engaged or interactive in solving problems using AI? | Much more engaged | 8 |
| Did you become more engaged or interactive in solving problems using AI? | No change | 2 |
| Did you become more engaged or interactive in solving problems using AI? | Much less engaged | 1 |
| orig_label | response | n |
|---|---|---|
| Helpfulness of generative AI for each use case [‘Vibe code’: generating statistical, network, or other advanced analyses] | Extremely helpful | 17 |
| Helpfulness of generative AI for each use case [‘Vibe code’: generating statistical, network, or other advanced analyses] | Very helpful | 14 |
| Helpfulness of generative AI for each use case [‘Vibe code’: generating statistical, network, or other advanced analyses] | Moderately helpful | 11 |
| Helpfulness of generative AI for each use case [‘Vibe code’: generating statistical, network, or other advanced analyses] | Slightly helpful | 1 |
| orig_label | response | n |
|---|---|---|
| Trust calibration [AI responses are transparent about uncertainty/limitations.] | Neutral | 15 |
| Trust calibration [AI responses are transparent about uncertainty/limitations.] | Agree | 13 |
| Trust calibration [AI responses are transparent about uncertainty/limitations.] | Disagree | 12 |
| Trust calibration [AI responses are transparent about uncertainty/limitations.] | Strongly disagree | 3 |
| “Vibe code” outcomes [I would be able to reproduce the analysis later with notes.] | Agree | 22 |
| “Vibe code” outcomes [I would be able to reproduce the analysis later with notes.] | Neutral | 8 |
| “Vibe code” outcomes [I would be able to reproduce the analysis later with notes.] | Disagree | 6 |
| “Vibe code” outcomes [I would be able to reproduce the analysis later with notes.] | Strongly agree | 5 |
| “Vibe code” outcomes [I would be able to reproduce the analysis later with notes.] | Strongly disagree | 2 |
| Impact on metagenomics learning [AI improved my understanding of MAG taxonomy.] | Agree | 16 |
| Impact on metagenomics learning [AI improved my understanding of MAG taxonomy.] | Neutral | 12 |
| Impact on metagenomics learning [AI improved my understanding of MAG taxonomy.] | Strongly agree | 8 |
| Impact on metagenomics learning [AI improved my understanding of MAG taxonomy.] | Disagree | 5 |
| Impact on metagenomics learning [AI improved my understanding of MAG taxonomy.] | Strongly disagree | 2 |
| Trust calibration [I can usually tell when AI is wrong.] | Agree | 23 |
| Trust calibration [I can usually tell when AI is wrong.] | Neutral | 12 |
| Trust calibration [I can usually tell when AI is wrong.] | Disagree | 5 |
| Trust calibration [I can usually tell when AI is wrong.] | Strongly agree | 3 |
| Trust calibration [I know how to verify AI-generated code.] | Agree | 20 |
| Trust calibration [I know how to verify AI-generated code.] | Neutral | 10 |
| Trust calibration [I know how to verify AI-generated code.] | Strongly agree | 7 |
| Trust calibration [I know how to verify AI-generated code.] | Disagree | 5 |
| Trust calibration [I know how to verify AI-generated code.] | Strongly disagree | 1 |
| Ethical alignment [AI use encouraged learning, not shortcuts.] | Agree | 16 |
| Ethical alignment [AI use encouraged learning, not shortcuts.] | Strongly agree | 10 |
| Ethical alignment [AI use encouraged learning, not shortcuts.] | Neutral | 9 |
| Ethical alignment [AI use encouraged learning, not shortcuts.] | Disagree | 8 |
| Impact on metagenomics learning [AI improved my overall conceptual grasp of metagenomics.] | Agree | 17 |
| Impact on metagenomics learning [AI improved my overall conceptual grasp of metagenomics.] | Strongly agree | 11 |
| Impact on metagenomics learning [AI improved my overall conceptual grasp of metagenomics.] | Neutral | 9 |
| Impact on metagenomics learning [AI improved my overall conceptual grasp of metagenomics.] | Strongly disagree | 4 |
| Impact on metagenomics learning [AI improved my overall conceptual grasp of metagenomics.] | Disagree | 2 |
| “Vibe code” outcomes [I could critically evaluate the appropriateness of those methods.] | Neutral | 20 |
| “Vibe code” outcomes [I could critically evaluate the appropriateness of those methods.] | Agree | 11 |
| “Vibe code” outcomes [I could critically evaluate the appropriateness of those methods.] | Strongly agree | 10 |
| “Vibe code” outcomes [I could critically evaluate the appropriateness of those methods.] | Disagree | 2 |
| Impact on metagenomics learning [AI helped connect genome properties with soil chemistry.] | Agree | 18 |
| Impact on metagenomics learning [AI helped connect genome properties with soil chemistry.] | Strongly agree | 11 |
| Impact on metagenomics learning [AI helped connect genome properties with soil chemistry.] | Neutral | 10 |
| Impact on metagenomics learning [AI helped connect genome properties with soil chemistry.] | Strongly disagree | 2 |
| Impact on metagenomics learning [AI helped connect genome properties with soil chemistry.] | Disagree | 2 |
| Ethical alignment [Using AI in this course felt appropriate and ethical.] | Agree | 22 |
| Ethical alignment [Using AI in this course felt appropriate and ethical.] | Neutral | 10 |
| Ethical alignment [Using AI in this course felt appropriate and ethical.] | Strongly agree | 9 |
| Ethical alignment [Using AI in this course felt appropriate and ethical.] | Strongly disagree | 1 |
| Ethical alignment [Using AI in this course felt appropriate and ethical.] | Disagree | 1 |
| Inquiry & exploration [AI helped me identify novel questions using NEON geographic variation.] | Agree | 24 |
| Inquiry & exploration [AI helped me identify novel questions using NEON geographic variation.] | Strongly agree | 9 |
| Inquiry & exploration [AI helped me identify novel questions using NEON geographic variation.] | Neutral | 6 |
| Inquiry & exploration [AI helped me identify novel questions using NEON geographic variation.] | Disagree | 4 |
| Inquiry & exploration [AI helped me connect MAGs to environmental gradients.] | Agree | 24 |
| Inquiry & exploration [AI helped me connect MAGs to environmental gradients.] | Strongly agree | 11 |
| Inquiry & exploration [AI helped me connect MAGs to environmental gradients.] | Neutral | 4 |
| Inquiry & exploration [AI helped me connect MAGs to environmental gradients.] | Disagree | 3 |
| Inquiry & exploration [AI helped me connect MAGs to environmental gradients.] | Strongly disagree | 1 |
| “Vibe code” outcomes [I understood at least the core idea of the advanced methods.] | Agree | 16 |
| “Vibe code” outcomes [I understood at least the core idea of the advanced methods.] | Strongly agree | 15 |
| “Vibe code” outcomes [I understood at least the core idea of the advanced methods.] | Neutral | 8 |
| “Vibe code” outcomes [I understood at least the core idea of the advanced methods.] | Disagree | 3 |
| “Vibe code” outcomes [I understood at least the core idea of the advanced methods.] | Strongly disagree | 1 |
| Code quality outcomes using AI [My code became more efficient (faster/simpler).] | Agree | 22 |
| Code quality outcomes using AI [My code became more efficient (faster/simpler).] | Strongly agree | 12 |
| Code quality outcomes using AI [My code became more efficient (faster/simpler).] | Neutral | 5 |
| Code quality outcomes using AI [My code became more efficient (faster/simpler).] | Disagree | 4 |
| Ethical alignment [I understand when/how to credit AI assistance.] | Agree | 25 |
| Ethical alignment [I understand when/how to credit AI assistance.] | Strongly agree | 11 |
| Ethical alignment [I understand when/how to credit AI assistance.] | Disagree | 3 |
| Ethical alignment [I understand when/how to credit AI assistance.] | Neutral | 3 |
| Ethical alignment [I understand when/how to credit AI assistance.] | Strongly disagree | 1 |
| “Vibe code” outcomes [AI-generated advanced code was runnable in our environment.] | Agree | 18 |
| “Vibe code” outcomes [AI-generated advanced code was runnable in our environment.] | Strongly agree | 14 |
| “Vibe code” outcomes [AI-generated advanced code was runnable in our environment.] | Neutral | 10 |
| “Vibe code” outcomes [AI-generated advanced code was runnable in our environment.] | Disagree | 1 |
| Ethical alignment [Clear guidelines were provided for AI use.] | Strongly agree | 17 |
| Ethical alignment [Clear guidelines were provided for AI use.] | Agree | 16 |
| Ethical alignment [Clear guidelines were provided for AI use.] | Neutral | 8 |
| Ethical alignment [Clear guidelines were provided for AI use.] | Strongly disagree | 1 |
| Ethical alignment [Clear guidelines were provided for AI use.] | Disagree | 1 |
| Impact on learning [AI increased my confidence in writing R code.] | Strongly agree | 20 |
| Impact on learning [AI increased my confidence in writing R code.] | Agree | 12 |
| Impact on learning [AI increased my confidence in writing R code.] | Neutral | 6 |
| Impact on learning [AI increased my confidence in writing R code.] | Disagree | 5 |
| Impact on metagenomics learning [AI improved my ability to form testable questions using NEON data.] | Agree | 16 |
| Impact on metagenomics learning [AI improved my ability to form testable questions using NEON data.] | Strongly agree | 16 |
| Impact on metagenomics learning [AI improved my ability to form testable questions using NEON data.] | Neutral | 10 |
| Impact on metagenomics learning [AI improved my ability to form testable questions using NEON data.] | Disagree | 1 |
| Trust calibration [AI sometimes overstates confidence in its answers.] | Agree | 22 |
| Trust calibration [AI sometimes overstates confidence in its answers.] | Strongly agree | 13 |
| Trust calibration [AI sometimes overstates confidence in its answers.] | Neutral | 7 |
| Trust calibration [AI sometimes overstates confidence in its answers.] | Disagree | 1 |
| Impact on metagenomics learning [AI helped me interpret R outputs for metagenomics.] | Strongly agree | 19 |
| Impact on metagenomics learning [AI helped me interpret R outputs for metagenomics.] | Agree | 15 |
| Impact on metagenomics learning [AI helped me interpret R outputs for metagenomics.] | Neutral | 5 |
| Impact on metagenomics learning [AI helped me interpret R outputs for metagenomics.] | Disagree | 3 |
| Impact on metagenomics learning [AI helped me interpret R outputs for metagenomics.] | Strongly disagree | 1 |
| Code quality outcomes using AI [My code became more readable (better comments, structure).] | Agree | 20 |
| Code quality outcomes using AI [My code became more readable (better comments, structure).] | Strongly agree | 15 |
| Code quality outcomes using AI [My code became more readable (better comments, structure).] | Neutral | 7 |
| Code quality outcomes using AI [My code became more readable (better comments, structure).] | Disagree | 1 |
| Code quality outcomes using AI [I relied on AI but still validated results.] | Agree | 20 |
other_cols <- setdiff(names(df_plot), likert_cols)
for (col in other_cols) {
cat("\n\n## ", name_map$orig[name_map$clean == col] %||% col, "\n\n", sep = "")
col_data <- df_plot[[col]]
if (is.numeric(col_data)) {
p <- plot_numeric(df_plot, col)
print(p)
} else if (is.factor(col_data)) {
p <- plot_unordered_factor(df_plot, col)
print(p)
tb <- df_plot %>% mutate(val = as.character(!!rlang::sym(col))) %>% count(val, sort = TRUE)
if (nrow(tb) <= 15) {
print(knitr::kable(tb, caption = paste("Counts for", col)))
} else {
print(knitr::kable(head(tb, 15), caption = paste("Top counts for", col, "(first 15 shown)")))
}
} else {
cat("No standard plot for column type: ", class(col_data)[1], "\n\n")
print(summary(col_data))
}
}
| val | n |
|---|---|
| Yes, I consent to participate in this survey. | 43 |
| val | n |
|---|---|
| None | 24 |
| Very limited (a few tutorials or labs) | 10 |
| Some (one course or self-study) | 6 |
| Extensive (multiple courses or projects) | 2 |
| Moderate (regular use in another language) | 1 |
| val | n |
|---|---|
| A few times per week | 17 |
| Daily | 17 |
| About once per week | 7 |
| I tried it once or twice | 2 |
| val | n |
|---|---|
| Extremely helpful | 26 |
| Very helpful | 9 |
| Moderately helpful | 5 |
| Slightly helpful | 2 |
| Not helpful | 1 |
| val | n |
|---|---|
| Extremely helpful | 19 |
| Very helpful | 13 |
| Moderately helpful | 8 |
| Slightly helpful | 2 |
| Not helpful | 1 |
| val | n |
|---|---|
| Extremely helpful | 18 |
| Very helpful | 12 |
| Moderately helpful | 7 |
| Not helpful | 3 |
| Slightly helpful | 3 |
| val | n |
|---|---|
| Very helpful | 17 |
| Extremely helpful | 16 |
| Moderately helpful | 7 |
| Slightly helpful | 2 |
| Not helpful | 1 |
| val | n |
|---|---|
| Extremely helpful | 15 |
| Very helpful | 13 |
| Moderately helpful | 7 |
| Slightly helpful | 6 |
| Not helpful | 2 |
| val | n |
|---|---|
| Very helpful | 18 |
| Extremely helpful | 11 |
| Moderately helpful | 9 |
| Slightly helpful | 3 |
| Not helpful | 2 |
| val | n |
|---|---|
| Very helpful | 13 |
| Moderately helpful | 12 |
| Extremely helpful | 9 |
| Slightly helpful | 6 |
| Not helpful | 3 |
| val | n |
|---|---|
| NA | 2 |
| -producing helpful explanations when codes do not run, providing simple code fixes | 1 |
| A lot of the time I asked AI to help explain certain coding functions or I would ask them why I am getting the error message I am getting when rendering my lab and that’s helped me learn from why I can’t write the code in certain ways. So AI has definitely helped me improve my coding syntax so that less errors come up when I render my labs. | 1 |
| AI can help clean out a code chunk by replacing verbose patterns with simpler, more readable alternatives — for example, instead of writing filter(!is.na(site_id), !is.na(phylum)) %>% count(site_id, phylum), AI might suggest drop_na(site_id, phylum) %>% count(site_id, phylum), which is shorter and easier to understand. | 1 |
| AI fixing errors in my code | 1 |
| AI has been helpful in providing responses to fix my coding errors. For example, I would tell CoPilot the code I was trying to run, and say it was not working and enter the specific “Error:…” I was getting. Copilot would then send back the correct code (most of the time), and explain where I went wrong which was really helpful so that I would not make the same mistake again. | 1 |
| AI was able to come up analyses and graphs for the data that I never would have thought of. It also provided the code for each analysis which was very helpful when trying to reproduce the graph in RStudio. | 1 |
| AI was very good at telling me what an error message meant, provided that I gave them the exact error message R was giving me. AI would often explain what the error message meant and then provide multiple common ways to solve this problem. | 1 |
| All of the assignments like Making a graph for neon image data | 1 |
| Anything I don’t know ai can help | 1 |
| Before we learned the definitions of regex patterns and I tried to ask AI to create patterns for effective character finding, I used AI to give an explanation of the reasoning and meaning of the regex patterns it generated. Even before we formally learned the skill, AI helped me think of advanced regex patterns. | 1 |
| Giving an example of the code and then explainging what each part does, making it easy to know what use/add to get the product i needed | 1 |
| Giving me different types of analysis I could do to see spatial autocorrelation for the MAG and metadata dataset | 1 |
| Having an idea on how you want data to be analyzed but not being sure of what kind of graphic would be best suited for that. AI can suggest a few different methods and write the bulk of the code required to set the graphic up in RStudio. | 1 |
| Here’s a specific example: my question to AI was: “what’s the difference between your solution and what I wrote?” AI gave me a step by step explanation of (1) what my code does and (2) problems my code causes (failing to address the problem). The specific problem I was working on was How to display a table that counts the number of MAGs by phylum at each site. AI was very helpful in all circumstances, especially in Suggesting R code to solve problems and Explaining R code syntax and logic. Those were my two top uses of AI. Of course, AI helped with all the other categories too, but for the most part, the two I just mentioned were the categories that I most often consulted AI for. I feel like the category Data wrangling with MAG taxonomy + genome properties + soil chemistry can be included underneath either of these two, because it was related to problem-solving. The reason I put Extremely helpful for all categories because of the ability to consult AI for really almost everything. For the two categories I mentioned above, these are the prompts I would ask “Here’s my code. It seems to me that it works fine, but can you verify that it really does?” Or, “What does this function do? What’s the difference between this one and this one?” Or, “Here’s the problem I’m trying to solve, and here’s my code so far. Can you help me with my code (either troubleshoot this error I’m getting or show me whether this is the best way to approach the problem)”. I took advantage of making the most out of AI by asking it to explain functions it used that I wasn’t familiar with. I also always tried to understand AI logic by walking myself through each line, one by one. The next two categories that I used AI for mostly in this course was Brainstorming research questions with NEON metagenomic data. ‘Vibe code’: generating statistical, network, or other advanced analyses kind of follows or falls under this. This is especially helpful because I don’t have a research background and while I can ask simple questions like “What phyla are enriched in these soil pH ranges?”, I still would need to expand on this question. My problem is that I’m not creative (maybe not curious enough?) with my questions. This is why using AI to jumpstart brainstorming is especially helpful, especially because it can quickly provide background information that might spark my curiosity. | 1 |
| val | n |
|---|---|
| NA | 2 |
| AI going in the wrong direction about my code | 1 |
| AI is very prompt-specific, so if a prompt does not reflect exactly what the person wants, it takes a lot of back and forth between the AI and the person to get a good result. | 1 |
| AI isnt the best at helping with MAG data or anything in terms of troubleshooting for working directory | 1 |
| AI made some graphs that were not accurate or did not have a good set up. Also certain commands it was not good at using. | 1 |
| AI responses that don’t provide a code or give super complicated unrunnable codes | 1 |
| AI telling me to install and load new libraries when I don’t even need them. | 1 |
| An unhelpful AI response might be overly vague, like ‘Just fix the code somehow’, which gives no actionable guidance. Another incorrect response could confidently suggest a function or method that doesn’t exist, leaving the user confused and misled. | 1 |
| For me, examples would be when the code simply doesn’t work. Sometimes it’s due to base R issues or packages and version incompatibility—things like that. I don’t know any technical terms to describe what the issues are more specifically. I also don’t have a good understanding of how computers work. One specific example is when I wanted to do an analysis of MAG data using a heat map based on soil moisture. My input was, “Here’s my code so far where I got the average soil temperature for each phyla. How do I make a heat map from here?” AI gave me a solution where I had to convert my data frame to a matrix first. The code didn’t work from there due to some issues with creating the matrix. I believe I could have troubleshooted some more, as well as learn more about matrices on my own, but in that moment I really just wanted a quick visual and wasn’t willing to spend time to learn about matrices. I think the only issue with AI feedback here is that my code is nuanced to the data I’m working with and AI doesn’t get to have the full picture. I admit I could have been less lazy here and try troubleshooting it myself! | 1 |
| For some of the more complicated data analysis there will be some lines where you get an error and try to use AI to solve it. However it can’t solve it (maybe due to package/R version incompatibility) and you end up going down a rabbit hole and wasting time. | 1 |
| Hardest to solve problems. If something did not work or wrong answer, needed to figure it out mostly on my own, AI hardly could fix it. | 1 |
| I found that some of the unhelpful/incorrect Ai responses typically had to do with sometimes I felt like it did not listen to my requests or it would suggest troubleshooting techniques that would not work. | 1 |
| I was trying to join two data sets but the IDs in the data sets had slightly different suffixes. The suggestion that AI was giving me wasn’t working in removing the suffix but it kept going around in the same circle. Eventually, AI was able to make the join work but I am not sure how… | 1 |
| If I used AI to generate new code, it would often assume file/column names. When I input my edited code (with corrected file and column names), it would solve problems in the code but still using the file names it originally created. Not a terrible issue, just annoying | 1 |
| In lab S3 Connecting a Github repo site with a new RStudio project. It kept giving me wrong code to link and due to that the Lab was not loading | 1 |
| val | n |
|---|---|
| Strongly agree | 19 |
| Agree | 12 |
| Neutral | 6 |
| Disagree | 5 |
| Stongly disagree | 1 |
| val | n |
|---|---|
| Strongly agree | 24 |
| Agree | 11 |
| Neutral | 5 |
| Disagree | 2 |
| Stongly disagree | 1 |
| val | n |
|---|---|
| Higher | 30 |
| Much higher | 7 |
| About the same | 5 |
| Much lower | 1 |
| val | n |
|---|---|
| 3+ hrs | 21 |
| 2-3 hrs | 12 |
| 1-2 hrs | 8 |
| 0.5-1 hrs | 1 |
| < 0.5 hr total | 1 |
| val | n |
|---|---|
| Sometimes | 28 |
| Often | 10 |
| Rarely | 3 |
| Very Often | 1 |
| NA | 1 |
| val | n |
|---|---|
| Ran and tested the code in R, Checked documentation or help pages, Asked follow-up questions to the AI | 6 |
| Ran and tested the code in R, Checked documentation or help pages, Asked follow-up questions to the AI, Consulted classmates, Consulted the instructor | 6 |
| Ran and tested the code in R, Asked follow-up questions to the AI | 4 |
| Ran and tested the code in R, Checked documentation or help pages, Asked follow-up questions to the AI, Consulted classmates | 3 |
| Ran and tested the code in R, Checked documentation or help pages, Asked follow-up questions to the AI, Consulted classmates, Consulted the instructor, Ignored or discarded AI suggestions | 3 |
| Asked follow-up questions to the AI, Consulted classmates, Consulted the instructor | 2 |
| Ran and tested the code in R, Asked follow-up questions to the AI, Consulted classmates, Consulted the instructor | 2 |
| Ran and tested the code in R, Asked follow-up questions to the AI, Consulted classmates, Consulted the instructor, Ignored or discarded AI suggestions | 2 |
| Ran and tested the code in R, Asked follow-up questions to the AI, Consulted classmates, Ignored or discarded AI suggestions | 2 |
| Ran and tested the code in R, Asked follow-up questions to the AI, Consulted the instructor, Ignored or discarded AI suggestions | 2 |
| Ran and tested the code in R, Asked follow-up questions to the AI, Ignored or discarded AI suggestions | 2 |
| Asked follow-up questions to the AI | 1 |
| Asked follow-up questions to the AI, Consulted classmates, Ignored or discarded AI suggestions | 1 |
| Checked documentation or help pages | 1 |
| Ran and tested the code in R, Asked follow-up questions to the AI, Consulted classmates | 1 |
| val | n |
|---|---|
| Incorrect R syntax or arguments, Overcomplicated solutions, Misinterpretation of MAG/soil data | 10 |
| Hallucinated functions or packages, Incorrect R syntax or arguments, Overcomplicated solutions, Misinterpretation of MAG/soil data | 4 |
| Hallucinated functions or packages, Incorrect R syntax or arguments, Overcomplicated solutions | 3 |
| Hallucinated functions or packages, Misinterpretation of MAG/soil data | 3 |
| Misinterpretation of MAG/soil data, Confident but unsupported claims | 3 |
| Incorrect R syntax or arguments, Misinterpretation of MAG/soil data | 2 |
| Incorrect R syntax or arguments, Overcomplicated solutions, Confident but unsupported claims | 2 |
| Misinterpretation of MAG/soil data | 2 |
| Overcomplicated solutions, Misinterpretation of MAG/soil data | 2 |
| Hallucinated functions or packages, Incorrect R syntax or arguments, Misinterpretation of MAG/soil data | 1 |
| Hallucinated functions or packages, Incorrect R syntax or arguments, Overcomplicated solutions, Misinterpretation of MAG/soil data, Confident but unsupported claims, Ethical concerns | 1 |
| Hallucinated functions or packages, Incorrect R syntax or arguments, Overcomplicated solutions, Misinterpretation of MAG/soil data, Confident but unsupported claims, sometimes, he is just a little dumb | 1 |
| Hallucinated functions or packages, Overcomplicated solutions | 1 |
| Hallucinated functions or packages, Overcomplicated solutions, Misinterpretation of MAG/soil data, Confident but unsupported claims | 1 |
| Incorrect R syntax or arguments | 1 |
| val | n |
|---|---|
| Clear | 27 |
| Very clear | 12 |
| Neutral | 3 |
| Unclear | 1 |
| val | n |
|---|---|
| Debugging with AI, Verifying AI output, Advanced analyses | 3 |
| Prompting strategies, Debugging with AI, Verifying AI output, Integrating AI with R | 3 |
| Verifying AI output | 3 |
| Debugging with AI, Integrating AI with R, Advanced analyses | 2 |
| Debugging with AI, Verifying AI output, Ethics & citation, Advanced analyses | 2 |
| Ethics & citation | 2 |
| Prompting strategies, Debugging with AI | 2 |
| Prompting strategies, Debugging with AI, Integrating AI with R | 2 |
| Prompting strategies, Debugging with AI, Verifying AI output | 2 |
| Prompting strategies, Verifying AI output, Ethics & citation | 2 |
| Debugging with AI, Ethics & citation | 1 |
| Debugging with AI, Verifying AI output | 1 |
| Debugging with AI, Verifying AI output, Ethics & citation | 1 |
| Debugging with AI, Verifying AI output, Ethics & citation, Integrating AI with R | 1 |
| Debugging with AI, Verifying AI output, Integrating AI with R, Advanced analyses | 1 |
| val | n |
|---|---|
| NA | 12 |
| N/A | 2 |
| AI skyrocketed my coding capabilities. However, I don’t feel very confident in coding without AI. This class would benefit from spending more time on ingraining R/coding basics before moving to advanced R coding and metagenomic analysis. Maybe the first half of the course could be ingraining both the basics in code and metagenomic analysis and the second half could be the explosive, exciting, AI based coding and analysis. Using AI was a world-opening experience for me in coding. | 1 |
| Ask people to discuss there code, or allow for people to do independent projects. I really enjoyed the last lab that was open ended. If we did the end of year project I think that I would have been able to utilize all the skills that I learned. | 1 |
| Covering more on ethics and AI use | 1 |
| Have a class specifically for how to ask copilot for help with R coding, including how to write a helpful prompt and dissect the answers so that you are able to use them in your actual code. | 1 |
| I definitely think that lab reports should require students to report the prompt that was used to generate any code they used, preceding an exercise. I think this is important data for this class and can be used to think of effective prompting strategies. |
One idea I had, is to use Monday discussions to do either class-wide or team/table debriefing in which we talk about what sort of code we are getting from AI. I think a collaborative aspect in this class would be helpful for keeping students on track together. | 1| |I feel like Debugging with AI is the most common issue I experience when using AI for code because what we are working on can be so nuanced. Because of the nuance, I’m not sure how feasible in-class support with AI debugging would be (in the context of a whole class period), especially if everyone is working on different analyses / project? I would say the same thing for Verifying AI output. I think AI is a useful tool used for assistance, but I also found that what we did in the course has been very valuable— namely doing the chapter outlines. They can take quite a while to get through, but I agree that it’s important for us to know the basics of R ourselves.
For Advanced analyses, maybe it would be helpful to have a brief overview in class of things like alpha-diversity and beta-diversity. I learned about this before in other classes (and don’t remember what they are), so maybe formally going over it in class, if only briefly, would be good. Maybe taking an additional lecture to explain more of what MAGs are and why they’re useful in research, since I didn’t get it the first time. Eventually I came to understand what they are. Also, personally I don’t know anything about analyzing data, so if we received some advice about things to pay attention to (for example, make sure you take a larger sample size. Or any research principles we aren’t aware of? And what is ANOVA test, if we happened to need to use it) from class, just briefly, that would help. As for using AI to help generate code for Advanced analyses, it helped so much.
Perhaps one thing I think would be good for this course is to require or at least highly encourage students to explain what their code chunk does, and put that explanation in the Quarto document above the code chunk. Or to put comments in code in cases where the code looks suspiciously flawless. We sometimes do these things by putting the header “AI note” and “Code chunk”, but I wonder whether it would be good for students to go further than minimally stating what prompt they asked AI. Either way, I suppose a student’s ability to gain some useful knowledge is up to how disciplined they are able to be when they have powerful resources like AI. | 1| |I had hoped that the class would be more focused on the NEON Lab data and allow more time to work with it. We only engaged with the dataset for the last 2 weeks of classes. And while the previous R sessions did build foundational skills that definitely helped in analyzing the NEON Lab data, it would have been more beneficial to introduce and work with the data earlier during the course. Because for me, doing so could have helped with better understanding the value of using coding tools for biological data. | 1| |I know students will use Al to help them in this course in one way or another but if there’s a way to help improve learning. I know many of us had no background use of coding at all and we kind of jumped in quickly so I would depend on Al a lot to simply just get my work done. | 1| |I think AI helped my learning expirence I would just add more to debugging and varifying AI like how to maybe do a monday class on this instead of a lab. | 1| |I think because there is a Monday and Wednesday portion, The Monday portion should be spent explaining what the lab on Wednesday will be. I found myself using AI a lot for things that I felt could’ve been discussed in class. | 1| |I think it was sometimes confusing to know exactly how to cite AI in the course, so more clarity on when/how it should be used in the earlier labs would be helpful. | 1| |I think it’s like a calculator, I would not use it for anything else. It works less well than google for research, but it works as expected when given complex prompts. You may need to amen/check the equation yourself for sure, but it will be able to give you a decent starting point/do the easy stuff faster than you. | 1| |I think when starting with AI sometimes it’s easy to just copy and paste the question we’re asked, but I think it would be helpful to start off with examples of how we can prompt AI to guide us in answering our problems. | 1|
| val | n |
|---|---|
| NA | 12 |
| AI helped me understand and learn a lot more in this course than I could have otherwise without it! | 1 |
| AI really helped understanding the coding. | 1 |
| AI removes the need to spend hours learning coding and allows me to focus on more important things | 1 |
| Ai really did help and I feel like it is needed for advanced code based on the level of most students in this class, it just made it so coding felt robotic and I learned a little less. | 1 |
| Good course to introduce someone to the use of AI in R, but would have been helpful/interesting to learn some of the basics beforehand. | 1 |
| I enjoyed this class and performed analyses I never would have thought of without AI suggestions. I would have liked to learn coding without AI first to establish a foundation, but ultimately, using AI allowed me to complete a lot more work and understand more functions in R code. | 1 |
| I feel like the effectiveness of AI in this course varies between students, so this survey is very interesting! I could see AI inhibiting learning if students used it heavily in the beginning of the course when we focused on R basics, because then that work is just busy work. I feel like I learned the most from the beginning of the course just using AI as an occasional troubleshooting tool, but depending on AI from the start would have been detrimental. | 1 |
| I genuinely think the point of AI is like computers and calculators, make complex work easier. I just think we should not confuse a glorified calculator with a friend, God’s word, or an actual intelligent person (Cogito, ergo sum). |
Even if it was an intelligent person, I would check their words and answers if I suspected it sounded too good to be true (that’s probably because by nature, I also have a tendency to say things with a lot of confidence even if they are not true—simply because I believe them). If someone came to me with the total confidence that there are three types of T cells, I would know better and tell them “that’s not true.” If they told me “a new type of IgG was discovered in a paper by Matt et al,” I’d have a tendency to say “yes? Can you show me?.” If I was told “Did you know there are over 300 types of turtles?” I may have a small doubt, but usually say “oh nice!” and accept it as a doubtful, but actual fact (and mess up and repeat it with total confidence to other people as a truth). Asking any question to AI comes with the understanding that it is only a computer and just does math. But even if it could think and was human, wouldn’t we also double-check their statement and thoughts? Or correct them, or ask for proofs? | 1| |I liked being able to use AI but I wish I knew what to do if I fall down a rabbit hole of incorrect codes with CoPilot. | 1| |I really did enjoy the course overall, I like the room and set up of working with a group. I think Dr. Blanchard was helpful when I went to office hours or needed help in class. I wish we learned a few more basic coding steps because I think I relied on AI too much. I still think it should be a big part of the course but just that a little more coding without it at the start | 1| |I think AI has its place in the modern world but that place is not everywhere. I understand the potential AI has for making coding more accessible for newcomers but it should not eliminate the learning process. A balance needs to be found between AI use and organic learning. | 1| |I think the integration of AI is helpful in beginner courses as sometimes AI has a good way to “dumb” things down almost to explain why the code produces the output that it does. Sometimes having a conversation with AI helps the learner understand a lot more than just reading the textbook because sometimes we need more examples than just the ones provided to see what the concept is trying to show us. | 1| |I wish there was less of a need to use AI in this course, but once things started getting complicated it was very hard to do anything without the use of AI, especially considering most of us in the class had no experience with coding of any sort. For example, I did not use AI for the first couple of labs, and that was on purpose because I did not want to have to rely on AI for everything I did. The first couple of labs were manageable to do without the use of AI, and they were just challenging enough where I was actually learning a lot of the basics of coding. However, after a certain point, I felt I needed to use AI to get the work done because the level of difficulty increased too much for me to figure out the coding on my own. After that point, I relied on AI too much, and I wasn’t learning anymore. | 1| |I would not have been able to complete this class without the assistance of AI and if you want to continue to have a large workload AI is 100% necessary and is helpful. It is more on the individual student themselves to actually make sure we learn the content rather than just copy and pasting. | 1|
If you’d like, I can also run this on your CSV and attach the resulting HTML (upload the CSV here), or paste a small tweak to center scales on Neutral.